home *** CD-ROM | disk | FTP | other *** search
/ SPACE 2 / SPACE - Library 2 - Volume 1.iso / apps / 131 / applic / phone.c < prev    next >
C/C++ Source or Header  |  1987-04-17  |  11KB  |  302 lines
  1. /*  Matt Leber
  2.  *  DP 245
  3.  *  Lab #4
  4.  *  March 18, 1987
  5.  */
  6.  
  7. #include <screen.h>         /*  Screen handling routines  */
  8. #include <osbind.h>         /*  Outputting functions for the ST  */
  9. #include <ctype.h>          /*  Contains the case conversion functions  */
  10. #include <stdio.h>          /*  Standard I/O functions and defs...  */
  11.  
  12. struct element
  13.   {
  14.   char lname[ 15 ];         /*  Up to fifteen characters for last name  */
  15.   char fname[ 15 ];         /*  Up to fifteen characters for first name  */
  16.   char phone_num[ 15 ];     /*  Phone number  */
  17.   };
  18.  
  19. /*  The following area is a global variable definition area  */
  20.  
  21.   int hinum = 0;            /*  Holds the highest number element used  */
  22.   struct element list[ 100 ];  /*  The master list  */
  23.  
  24.  /**************************************************************************
  25.  *  toup( string );  -  Converts all of string to upper case, no returns   *
  26.  **************************************************************************/
  27.  
  28. void toup( string )
  29.  
  30. char *string;  /*  Holds the string to be converted  */
  31.  
  32.   {
  33.   while ( *string != '\0' )    /*  Until end of string  */
  34.     {
  35.     *string = toupper( *string ); /*  Convert character to upper case  */
  36.     ++string;                     /*  Go to next character  */
  37.     }
  38.   }
  39.  
  40.  /*************************************************************
  41.  * add( &info );  -  Adds the information in info to the list *
  42.  *                -  Returns 1 if not successful              *
  43.  *                -  Returns 0 if successful                  *
  44.  *************************************************************/
  45.  
  46. add( info )
  47.  
  48. struct element *info;
  49.  
  50.   {
  51.   if ( hinum < 100 )       /*  Check to see if we have any space available  */
  52.     {
  53.     strcpy( list[ hinum ].lname , info->lname);   /*  copy into main list */
  54.     strcpy( list[ hinum ].fname , info->fname);
  55.     strcpy( list[ hinum ].phone_num , info->phone_num);
  56.     ++hinum;             /*  Increment highest element number  */
  57.     return( 0 );
  58.     }
  59.   return( 1 );  /*  If not successfull, return an error  */
  60.   }
  61.  
  62.  /**********************************************************
  63.  *  delete( ele_num );  -  Deletes element number ele_num  *
  64.  *       Returns  :  0 - Element was deleted               *
  65.  *                   1 - Element doesn't exist             *
  66.  **********************************************************/
  67.  
  68. delete( ele_num )
  69.  
  70. int ele_num;          /*  Holds the number of the element to be deleted  */
  71.  
  72.   {
  73.   if ( ele_num >= hinum )
  74.     return( 1 );          /*  Check to see if the element exists  */
  75.  
  76.   --hinum;              /*  Shorten the length of the list  */
  77.  
  78.   while ( ele_num < hinum )
  79.     {                         /*  Copy each element down the list  */
  80.     strcpy( list[ ele_num ].lname , list[ ele_num + 1 ].lname );
  81.     strcpy( list[ ele_num ].fname , list[ ele_num + 1 ].fname );
  82.     strcpy( list[ ele_num ].phone_num , list[ ele_num +1 ].phone_num );
  83.     ++ele_num;            /*  Go to next element  */
  84.     }
  85.   return( 0 );       /*  Return an O.K.  */
  86.   }
  87.  
  88.  /*************************************************************************
  89.  *  get( &info );  -  Returns the number of the element that matches the  *
  90.  *                    information in info.  Start = Starting element      *
  91.  *                    Returns -1 if there is no match.  Individual        *
  92.  *                    strings that are empty will not be checked.         *
  93.  *************************************************************************/
  94.  
  95. get( info , start )
  96.  
  97. struct element *info;
  98. int start;
  99.  
  100.   {
  101.   int count;
  102.  
  103.   for ( count = start ; count < hinum ; ++count )
  104.     {
  105.     if ( info->fname[ 0 ] == '\0' ||     /*  Checking the first name  */
  106.          strcmp( info->fname , list[ count ].fname ) == 0)
  107.       {
  108.       if ( info->lname[ 0 ] == '\0' ||   /*  Checking the last name  */
  109.          strcmp( info->lname , list[ count ].lname ) == 0)
  110.         return( count );     /*  Match was found, return the number  */
  111.       }
  112.     }
  113.   return( -1 );            /*  Did not find a match  */
  114.   }
  115.  
  116.  /*****************************************************************
  117.  *  save_lst();  -  Saves the list.  Returns 1 if not successful  *
  118.  *****************************************************************/
  119.  
  120. save_lst()
  121.  
  122.   {
  123.   FILE *fp;
  124.  
  125.   int status;
  126.  
  127.   if (( fp = fopen( "PHONE.DAT" , "w" )) == NULL )
  128.     return( 1 );      /*  Return an error if there is a problem  */
  129.  
  130.   status = fwrite( (char *) list , sizeof( struct element ) , hinum , fp );
  131.  
  132.   fclose( fp );
  133.  
  134.   if ( status < hinum || status < 1 )
  135.     return( 1 );           /*  Return an error if there is a problem  */
  136.   }
  137.  
  138.  /*********************************************************************
  139.  *  read_lst();  -  This function will read the list off of the disk  *
  140.  *********************************************************************/
  141.  
  142. void read_lst()
  143.  
  144.   {
  145.   FILE *fp;            /*  Define the pointer to file buffer  */
  146.  
  147.   hinum = 0;           /*  Set beginning of the list  */
  148.  
  149.   if (( fp = fopen( "PHONE.DAT" , "r" )) != NULL )
  150.     {                 /*  Check to see if file is O.K.  */
  151.     hinum = fread( (char *) list , sizeof( struct element ) , 100 , fp );
  152.     fclose( fp );        /*   Close file    */
  153.     }
  154.   }
  155.  
  156.  /*****************************************************************************
  157.  *  edit_info( ele_num );  -  Edits the information in element number ele_num *
  158.  *                         -  No returns                                      *
  159.  *****************************************************************************/
  160.  
  161. void edit_info( ele_num )
  162.  
  163. int ele_num;
  164.  
  165.   {
  166.   if ( ele_num >= 0 && ele_num < hinum )
  167.     {
  168.     char buffer[ 15 ];               /*  Temporary inputing buffer  */
  169.     cls();
  170.  
  171.     Cconws("Present first name : "); /*  Get first name  */
  172.     Cconws( list[ ele_num ].fname );
  173.     Cconws("\n\rNew first name or <RETURN> to keep : ");
  174.     gets( buffer );
  175.     toup( buffer );      /*  Convert it to upper case  */
  176.     if ( buffer[ 0 ] != '\0' )       /*  If they inputed a name, move it in  */
  177.       strcpy( list[ ele_num ].fname , buffer );
  178.  
  179.     Cconws("\n\rPresent last name : ");  /*  Get last name  */
  180.     Cconws( list[ ele_num ].lname );
  181.     Cconws("\n\rNew last name or <RETURN> to keep : ");
  182.     gets( buffer );
  183.     toup( buffer );     /*  Convert it to upper case  */
  184.     if ( buffer[ 0 ] != '\0' )       /*  If they inputed, move it in  */
  185.       strcpy( list[ ele_num ].lname , buffer );
  186.  
  187.     Cconws("\n\rPresent Phone number : ");  /*  Get the phone number  */
  188.     Cconws( list[ ele_num ].phone_num );
  189.     Cconws("\n\rNew phone number or <RETURN> to keep : ");
  190.     gets( buffer );
  191.     if ( buffer[ 0 ] != '\0' )
  192.       strcpy( list[ ele_num ].phone_num , buffer );
  193.     }
  194.   }
  195.  
  196.  /****************************************************************************
  197.  *  usage();  -  This function displays a message on the requirements of the *
  198.  *               command line parameters.  And then exits to DOS             *
  199.  ****************************************************************************/
  200.  
  201. usage()
  202.  
  203.   {
  204.   char c;
  205.  
  206.   Cconws("\n\rUsage : PHONE [+?-] Lastname [Firstname] [Phone Number]\n\r");
  207.   Cconws("+  -  Add entry, must have All above information\n\r");
  208.   Cconws("-  -  Delete entry, must have Lastname and Firstname\n\r");
  209.   Cconws("?  -  Edit entry, must have Lastname and Firstname\n\r\n");
  210.   Cconws("If above parameters are omited, program will list phone numbers\n\r");
  211.   Cconws("of everybody with Lastname unless a specific Firstname is given\n\r\n");
  212.   Cconws("Press any key to continue...\n\r");
  213.   c = Crawcin();  
  214.   exit( 1 );
  215.   }
  216.  
  217.  /*******************************************************
  218.  *  main()  -  This is the main section of the program  *
  219.  *******************************************************/
  220.  
  221. main( argc , argv )
  222.  
  223. int argc;
  224. char *argv[];
  225.  
  226.   {
  227.   int status;                /*  Will hold return statuses  */
  228.   struct element in_info;    /*  Temporary command line information  */
  229.  
  230.   for( status = 0 ; status < argc ; ++status )
  231.     toup( argv[ status ] );         /*  Convert everything to upper case  */
  232.  
  233.   if ( argc < 2 )
  234.     usage();         /*  Display usage message and exit to dos  */
  235.  
  236.   read_lst();        /*  Read in the master list if it exists  */
  237.  
  238.   if ( strlen( argv[ 1 ] ) == 1 )
  239.     switch( *argv[ 1 ] )         /*  Checking for +, -, or ?  */
  240.       {
  241.       case '+' :  if ( argc < 5 )
  242.                     usage();     /*  Check for valid number of parameters  */
  243.                   strcpy( in_info.lname , argv[ 2 ] );
  244.                   strcpy( in_info.fname , argv[ 3 ] );
  245.                   strcpy( in_info.phone_num , argv[ 4 ] );
  246.                         /*  Copy info into structure  */
  247.                   if ( get( &in_info , 0 ) > -1 )
  248.                     {
  249.                     Cconws("Name already exists!  Delete or modify...\n\r");
  250.                     exit( 1 );
  251.                     }
  252.  
  253.                   add( &in_info );
  254.                   exit( save_lst() );
  255.                   break;
  256.  
  257.       case '-' :  if ( argc < 4 )
  258.                     usage();     /*  Check for valid number of parameters  */
  259.                   strcpy( in_info.lname , argv[ 2 ] );
  260.                   strcpy( in_info.fname , argv[ 3 ] );
  261.                   status = get( &in_info , 0 );
  262.                   if ( status > -1 )
  263.                     delete( status );    /*  If we find a match, delete it  */
  264.                   exit( save_lst() );    /*  Returns error code to op system */
  265.                   break;
  266.       case '?' :  if ( argc < 4 )
  267.                     usage();
  268.                   strcpy( in_info.lname , argv[ 2 ] );
  269.                   strcpy( in_info.fname , argv[ 3 ] );
  270.                   status = get( &in_info , 0 );
  271.                   if ( status > -1 )
  272.                     edit_info( status );
  273.                   exit( save_lst() );    /*  Returns error code to op system */
  274.                   break;
  275.       default :   usage();
  276.                   break;
  277.       }
  278.   strcpy( in_info.lname , argv[ 1 ] );
  279.  
  280.   if ( argc < 3 )
  281.     in_info.fname[ 0 ] = '\0';         /*  If no first name, make it blank  */
  282.   else
  283.     strcpy( in_info.fname , argv[ 2 ] );  /*  Otherwise give it first name  */
  284.  
  285.   status = -1;
  286.  
  287.   while(( status = get( &in_info , status + 1)) > -1 )
  288.     {
  289.     Cconws( "Name         : ");
  290.     Cconws( list[ status ].fname );
  291.     Cconws( " " );
  292.     Cconws( list[ status ].lname );
  293.     Cconws( "\n\rPhone Number : " );
  294.     Cconws( list[ status ].phone_num );
  295.     Cconws( "\n\n\r" );
  296.     }
  297.  
  298.   Cconws("Press any key to continue...\n\r");
  299.   status = Crawcin();     /*  Wait for a key to be pressed  */
  300.   exit(0);
  301.   }
  302.